TypeScript Shablon Literallarini Tahlil Qilish: Satr Tiplarini Ilg'or Manipulyatsiyasi

TypeScript-ning tiplar tizimi kompilyatsiya vaqtida ma'lumotlarni manipulyatsiya qilish va tasdiqlash uchun kuchli vositalarni taqdim etadi. Ushbu vositalar orasida shablon literallari satr tiplarini manipulyatsiya qilishga o'ziga xos yondashuvni taklif qiladi. Ushbu maqola shablon literallarini tahlil qilishning ilg'or jihatlarini chuqur o'rganib, satrga asoslangan ma'lumotlar uchun murakkab tip darajasidagi mantiqni qanday yaratishni ko'rsatadi.

Shablon Literalli Tiplar Nima?

TypeScript 4.1 versiyasida taqdim etilgan shablon literalli tiplar satr literallari va boshqa tiplarga asoslangan holda satr tiplarini aniqlash imkonini beradi. Ular JavaScript-dagi shablon literallariga o'xshab, tipni aniqlash uchun teskari tirnoqlardan (`) foydalanadi.

Masalan:

            type Color = "red" | "green" | "blue";
type Shade = "light" | "dark";

type ColorCombination = `${Shade} ${Color}`;

// ColorCombination endi "light red" | "light green" | "light blue" | "dark red" | "dark green" | "dark blue" bo'ladi

            

              
                Copy
              
            
          

Bu oddiy ko'rinadigan xususiyat kompilyatsiya vaqtida satrlarni qayta ishlash uchun keng imkoniyatlarni ochib beradi.

Shablon Literalli Tiplaridan Asosiy Foydalanish

Ilg'or texnikalarga sho'ng'ishdan oldin, keling, ba'zi fundamental foydalanish holatlarini ko'rib chiqaylik.

Satr Literallarini Birlashtirish

Yangi satr tiplarini yaratish uchun satr literallari va boshqa tiplarni osongina birlashtirishingiz mumkin:

            type Greeting = `Hello, ${string}!`;

// Foydalanishga misol
const greet = (name: string): Greeting => `Hello, ${name}!`;

const message: Greeting = greet("World"); // To'g'ri
const invalidMessage: Greeting = "Goodbye, World!"; // Xato: '"Goodbye, World!"' tipi '`Hello, ${string}!`' tipiga tayinlanmaydi.

            

              
                Copy
              
            
          

Birlashma Tiplaridan Foydalanish

Birlashma tiplari bir nechta mumkin bo'lgan qiymatlar kombinatsiyasi sifatida tipni aniqlash imkonini beradi. Shablon literallari murakkabroq satr tiplari birlashmalarini yaratish uchun birlashma tiplarini o'z ichiga olishi mumkin:

            type HTTPMethod = "GET" | "POST" | "PUT" | "DELETE";
type Endpoint = `/api/users` | `/api/products`;

type Route = `${HTTPMethod} ${Endpoint}`;

// Route endi "GET /api/users" | "POST /api/users" | "PUT /api/users" | "DELETE /api/users" | "GET /api/products" | "POST /api/products" | "PUT /api/products" | "DELETE /api/products" bo'ladi

            

              
                Copy
              
            
          

Shablon Literallarini Tahlil Qilishning Ilg'or Texnikalari

Shablon literalli tiplarning haqiqiy kuchi ularni satr tiplarini tahlil qilish va manipulyatsiya qilish uchun shartli tiplar va tipni aniqlash kabi boshqa ilg'or TypeScript xususiyatlari bilan birlashtirish qobiliyatidadir.

Satr Tipining Qismlarini Aniqlash

Satr tipining ma'lum qismlarini ajratib olish uchun shartli tip ichida infer kalit so'zidan foydalanishingiz mumkin. Bu satr tiplarini tahlil qilish uchun asosdir.

Fayl nomidan fayl kengaytmasini ajratib oladigan tipni ko'rib chiqing:

            type GetFileExtension = T extends `${string}.${infer Extension}` ? Extension : never;

// Misollar
type Extension1 = GetFileExtension<"myFile.txt">; // "txt"
type Extension2 = GetFileExtension<"anotherFile.image.jpg">; // "image.jpg" (oxirgi kengaytmani oladi)
type Extension3 = GetFileExtension<"noExtension">; // never

            

              
                Copy
              
            
          

Ushbu misolda shartli tip kiruvchi T tipining ${string}.${infer Extension} naqshiga mos kelishini tekshiradi. Agar mos kelsa, u oxirgi nuqtadan keyingi qismni Extension tip o'zgaruvchisiga chiqaradi va uni qaytaradi. Aks holda, u never qaytaradi.

Bir Nechta Chiqarishlar Bilan Tahlil Qilish

Bir vaqtning o'zida satr tipining bir nechta qismini ajratib olish uchun bitta shablon literalida bir nechta infer kalit so'zidan foydalanishingiz mumkin.

            type ParseConnectionString = 
  T extends `${infer Protocol}://${infer Host}:${infer Port}` ?
    { protocol: Protocol, host: Host, port: Port } : never;

// Misol
type Connection = ParseConnectionString<"http://localhost:3000">; 
// { protocol: "http", host: "localhost", port: "3000" }

type InvalidConnection = ParseConnectionString<"invalid-connection">; // never

            

              
                Copy
              
            
          

Bu tip ulanish satrini uning protokoli, xosti va port komponentlariga ajratadi.

Murakkab Tahlil Uchun Rekursiv Tip Ta'riflari

Murakkabroq satr tuzilmalari uchun rekursiv tip ta'riflaridan foydalanishingiz mumkin. Bu sizga kerakli natijaga erishmaguningizcha satr tipining qismlarini qayta-qayta tahlil qilish imkonini beradi.

Aytaylik, siz satrni tip darajasida alohida belgilar massiviga bo'lmoqchisiz. Bu ancha murakkab.

            type StringToArray = 
  T extends `${infer Char}${infer Rest}`
    ? StringToArray
    : Acc;

// Misol
type MyArray = StringToArray<"hello">; // ["h", "e", "l", "l", "o"]

            

              
                Copy
              
            
          

Tushuntirish:

• StringToArray<T extends string, Acc extends string[] = []>: Bu StringToArray deb nomlangan umumiy tipni aniqlaydi, u kirish sifatida T satr tipini va standart qiymati bo'sh satrlar massivi bo'lgan ixtiyoriy Acc akkumulyatorini qabul qiladi. Akkumulyator belgilarni qayta ishlash jarayonida saqlaydi.
• T extends `${infer Char}${infer Rest}`: Bu shartli tip tekshiruvi. U kiruvchi T satrini birinchi belgi Char va qolgan satr Rest ga bo'lish mumkinligini tekshiradi. infer kalit so'zi bu qismlarni ushlab olish uchun ishlatiladi.
• StringToArray<Rest, [...Acc, Char]>: Agar bo'linish muvaffaqiyatli bo'lsa, biz StringToArray ni satrning Rest qismi va yangi akkumulyator bilan rekursiv ravishda chaqiramiz. Yangi akkumulyator mavjud Acc ni yoyish va joriy Char belgisini oxiriga qo'shish orqali yaratiladi. Bu belgini to'planayotgan massivga samarali qo'shadi.
• Acc: Agar satr bo'sh bo'lsa (shartli tip bajarilmasa, ya'ni boshqa belgilar qolmagan bo'lsa), biz to'plangan Acc massivini qaytaramiz.

Bu misol satr tiplarini manipulyatsiya qilishda rekursiyaning kuchini namoyish etadi. Har bir rekursiv chaqiruv bitta belgini ajratib oladi va uni satr bo'sh bo'lguncha massivga qo'shadi.

Ajratgichlar Bilan Ishlash

Shablon literallarini satrlarni tahlil qilish uchun ajratgichlar bilan osongina ishlatish mumkin. Aytaylik, siz vergul bilan ajratilgan so'zlarni ajratib olmoqchisiz.

            type SplitString = 
  T extends `${infer First}${D}${infer Rest}`
    ? [First, ...SplitString]
    : [T];

// Misol
type Words = SplitString<"apple,banana,cherry", ",">; // ["apple", "banana", "cherry"]

            

              
                Copy
              
            
          

Bu tip D ajratgichining har bir uchragan joyida satrni rekursiv ravishda bo'ladi.

Amaliy Qo'llanilishlar

Ushbu ilg'or shablon literallarini tahlil qilish texnikalari TypeScript loyihalarida ko'plab amaliy qo'llanilishlarga ega.

Ma'lumotlarni Tasdiqlash (Validatsiya)

Siz kompilyatsiya vaqtida satrga asoslangan ma'lumotlarni ma'lum naqshlarga muvofiqligini tasdiqlashingiz mumkin. Masalan, elektron pochta manzillari, telefon raqamlari yoki kredit karta raqamlarini tasdiqlash. Ushbu yondashuv dastlabki bosqichda fikr-mulohaza beradi va ish vaqtidagi xatolarni kamaytiradi.

Bu yerda soddalashtirilgan elektron pochta manzili formatini tasdiqlash misoli keltirilgan:

            type EmailFormat = `${string}@${string}.${string}`;

const validateEmail = (email: string): email is EmailFormat => {
  // Haqiqatda, to'g'ri elektron pochta validatsiyasi uchun ancha murakkab regex ishlatiladi.
  // Bu faqat namoyish maqsadida.
  return /.+@.+\..+/.test(email);
}

const validEmail: EmailFormat = "user@example.com"; // To'g'ri
const invalidEmail: EmailFormat = "invalid-email"; // 'string' tipi '`${string}@${string}.${string}`' tipiga tayinlanmaydi.

if(validateEmail(validEmail)) {
    console.log("To'g'ri elektron pochta");
}

if(validateEmail("invalid-email")) {
  console.log("Bu chop etilmaydi.");
}

            

              
                Copy
              
            
          

Ish vaqtida regex bilan validatsiya qilish tip tekshiruvchi cheklovni to'liq ta'minlay olmaydigan hollarda (masalan, tashqi manbalardan kelgan ma'lumotlar bilan ishlaganda) hali ham zarur bo'lsa-da, EmailFormat tipi kompilyatsiya vaqtida qimmatli birinchi himoya chizig'ini ta'minlaydi.

API Endpointlarini Yaratish

Shablon literallari asosiy URL va bir qator parametrlarga asoslangan holda API endpoint tiplarini yaratish uchun ishlatilishi mumkin. Bu API'lar bilan ishlashda izchillik va tip xavfsizligini ta'minlashga yordam beradi.

            type BaseURL = "https://api.example.com";
type Resource = "users" | "products";
type ID = string | number;

type GetEndpoint = `${BaseURL}/${T}/${U}`;

// Misollar
type UserEndpoint = GetEndpoint<"users", 123>; // "https://api.example.com/users/123"
type ProductEndpoint = GetEndpoint<"products", "abc-456">; // "https://api.example.com/products/abc-456"

            

              
                Copy
              
            
          

Kod Generatsiyasi

Ancha ilg'or stsenariylarda shablon literalli tiplar kod generatsiyasi jarayonlarining bir qismi sifatida ishlatilishi mumkin. Masalan, sxemaga asoslangan SQL so'rovlarini yaratish yoki konfiguratsiya fayliga asoslangan UI komponentlarini yaratish.

Internatsionalizatsiya (i18n)

Shablon literallari i18n stsenariylarida qimmatli bo'lishi mumkin. Masalan, tarjima kalitlari ma'lum bir nomlash qoidasiga amal qiladigan tizimni ko'rib chiqing:

            type SupportedLanguages = 'en' | 'es' | 'fr';
type TranslationKeyPrefix = 'common' | 'product' | 'checkout';

type TranslationKey = `${TPrefix}.${string}`;

// Foydalanishga misol:
const getTranslation = (key: TranslationKey, lang: SupportedLanguages): string => {
  // Kalit va til asosida resurs to'plamidan tarjimani olishni simulyatsiya qilish
  const translations: Record> = {
    'common.greeting': {
      en: 'Hello',
      es: 'Hola',
      fr: 'Bonjour',
    },
    'product.description': {
      en: 'A fantastic product!',
      es: '¡Un producto fantástico!',
      fr: 'Un produit fantastique !',
    },
  };

  const translation = translations[key]?.[lang];
  return translation || `Tarjima topilmadi: kalit - ${key}, til - ${lang}`;
};

const englishGreeting = getTranslation('common.greeting', 'en'); // Hello
const spanishDescription = getTranslation('product.description', 'es'); // ¡Un producto fantástico!
const unknownTranslation = getTranslation('nonexistent.key' as TranslationKey, 'en'); // Tarjima topilmadi: kalit - nonexistent.key, til - en

            

              
                Copy
              
            
          

TranslationKey tipi barcha tarjima kalitlarining izchil formatga rioya qilishini ta'minlaydi, bu esa tarjimalarni boshqarish jarayonini soddalashtiradi va xatolarning oldini oladi.

Cheklovlar

Shablon literalli tiplar kuchli bo'lsa-da, ularning cheklovlari ham bor:

• Murakkablik: Murakkab tahlil mantig'i tezda o'qish va qo'llab-quvvatlash uchun qiyin bo'lib qolishi mumkin.
• Ishlash samaradorligi: Shablon literalli tiplardan keng foydalanish, ayniqsa katta loyihalarda, kompilyatsiya vaqtidagi ishlash samaradorligiga ta'sir qilishi mumkin.
• Tip xavfsizligidagi bo'shliqlar: Elektron pochta validatsiyasi misolida ko'rsatilganidek, kompilyatsiya vaqtidagi tekshiruvlar ba'zan etarli bo'lmaydi. Tashqi ma'lumotlar qat'iy formatlarga rioya qilishi kerak bo'lgan hollarda ish vaqtidagi validatsiya hali ham zarur.

Eng Yaxshi Amaliyotlar

Shablon literalli tiplardan samarali foydalanish uchun quyidagi eng yaxshi amaliyotlarga rioya qiling:

• Sodda tuting: Murakkab tahlil mantig'ini kichikroq, boshqariladigan tiplarga bo'ling.
• Tiplaringizni hujjatlashtiring: Shablon literalli tiplaringizning maqsadi va ishlatilishini aniq hujjatlashtiring.
• Tiplaringizni sinovdan o'tkazing: Tiplaringiz kutilganidek ishlashiga ishonch hosil qilish uchun birlik testlarini yarating.
• Kompilyatsiya vaqti va ish vaqti validatsiyasini muvozanatlashtiring: Asosiy validatsiya uchun shablon literalli tiplardan, murakkabroq stsenariylar uchun esa ish vaqti tekshiruvlaridan foydalaning.

Xulosa

TypeScript shablon literalli tiplari kompilyatsiya vaqtida satr tiplarini manipulyatsiya qilishning kuchli va moslashuvchan usulini taqdim etadi. Shablon literallarini shartli tiplar va tipni aniqlash bilan birlashtirib, siz satrga asoslangan ma'lumotlarni tahlil qilish, tasdiqlash va o'zgartirish uchun murakkab tip darajasidagi mantiqni yaratishingiz mumkin. Ko'rib chiqilishi kerak bo'lgan cheklovlar mavjud bo'lsa-da, shablon literalli tiplardan foydalanishning tip xavfsizligi va kodni qo'llab-quvvatlash nuqtai nazaridan afzalliklari sezilarli bo'lishi mumkin.

Ushbu ilg'or texnikalarni o'zlashtirib, dasturchilar yanada mustahkam va ishonchli TypeScript ilovalarini yaratishlari mumkin.

Qo'shimcha O'rganish

Shablon literalli tiplar haqidagi tushunchangizni chuqurlashtirish uchun quyidagi mavzularni o'rganishni ko'rib chiqing:

• Xaritalangan Tiplar: Shablon literalli tiplarga asoslangan holda obyekt tiplarini qanday o'zgartirishni o'rganing.
• Yordamchi Tiplar: Shablon literalli tiplar bilan birgalikda ishlatilishi mumkin bo'lgan o'rnatilgan TypeScript yordamchi tiplarini o'rganing.
• Ilg'or Shartli Tiplar: Murakkabroq tip darajasidagi mantiq uchun shartli tiplarning imkoniyatlariga chuqurroq sho'ng'ing.